JavaScript Closures Advanced: Memory Management and Scope Preservation

JavaScript க்ளோஷர்கள் ஒரு அடிப்படை கருத்தாகும், இது ஒரு செயல்பாட்டின் திறனாக "நினைவில் கொள்ள" மற்றும் அதன் சுற்றுப்புற ஸ்கோப்பில் இருந்து மாறிகளை அணுகுவது, வெளிப்புற செயல்பாடு முடிந்த பின்னரும். இந்த எளிய பொறிமுறையானது நினைவக மேலாண்மைக்கு ஆழமான தாக்கங்களை ஏற்படுத்துகிறது மற்றும் சக்திவாய்ந்த நிரலாக்க முறைகளை அனுமதிக்கிறது. இந்த கட்டுரை க்ளோஷர்களின் மேம்பட்ட அம்சங்களை ஆராய்கிறது, நினைவகத்தில் அவற்றின் தாக்கம் மற்றும் ஸ்கோப் பாதுகாப்பின் நுணுக்கங்களை ஆராய்கிறது.

க்ளோஷர்களைப் புரிந்துகொள்வது: ஒரு சுருக்கம்

மேம்பட்ட கருத்துகளில் மூழ்குவதற்கு முன், க்ளோஷர்கள் என்றால் என்ன என்பதை சுருக்கமாக பார்ப்போம். சாராம்சத்தில், ஒரு செயல்பாடு அதன் வெளிப்புற (மூடும்) செயல்பாட்டின் ஸ்கோப்பில் இருந்து மாறிகளை அணுகும் போதெல்லாம் ஒரு க்ளோஷர் உருவாக்கப்படுகிறது. வெளிப்புற செயல்பாடு திரும்பிய பின்னரும் இந்த மாறிகளைத் தொடர்ந்து அணுகுவதற்கு க்ளோஷர் உள் செயல்பாட்டை அனுமதிக்கிறது. ஏனென்றால், உள் செயல்பாடு வெளிப்புற செயல்பாட்டின் லெக்சிகல் சூழலுக்கான குறிப்பை பராமரிக்கிறது.

லெக்சிகல் சூழல்: லெக்சிகல் சூழலை செயல்பாடு உருவாக்கப்பட்ட நேரத்தில் அனைத்து மாறி மற்றும் செயல்பாடு அறிவிப்புகளையும் வைத்திருக்கும் வரைபடமாக நினைத்துப் பாருங்கள். இது ஸ்கோப்பின் ஸ்னாப்ஷாட் போன்றது.

ஸ்கோப் செயின்: ஒரு செயல்பாடு உள்ளே ஒரு மாறி அணுகப்படும்போது, ​​JavaScript முதலில் அதை செயல்பாட்டின் சொந்த லெக்சிகல் சூழலில் தேடுகிறது. கண்டுபிடிக்கவில்லை என்றால், அது ஸ்கோப் செயினை ஏறி, உலகளாவிய ஸ்கோப்பை அடையும் வரை வெளிப்புற செயல்பாடுகளின் லெக்சிகல் சூழல்களில் பார்க்கிறது. லெக்சிகல் சூழல்களின் இந்த சங்கிலி க்ளோஷர்களுக்கு முக்கியமானது.

க்ளோஷர்கள் மற்றும் நினைவக மேலாண்மை

க்ளோஷர்களின் மிக முக்கியமான, மற்றும் சில நேரங்களில் கவனிக்கப்படாத அம்சங்களில் ஒன்று, நினைவக மேலாண்மையில் அவற்றின் தாக்கம். க்ளோஷர்கள் அவற்றின் சுற்றுப்புற ஸ்கோப்புகளில் மாறிகளுக்கான குறிப்புகளைப் பராமரிப்பதால், க்ளோஷர் இருக்கும் வரை இந்த மாறிகள் குப்பை சேகரிக்கப்பட முடியாது. கவனமாக கையாளவில்லை என்றால் இது நினைவக கசிவுகளுக்கு வழிவகுக்கும். எடுத்துக்காட்டுகளுடன் இதை ஆராய்வோம்.

தற்செயலான நினைவக தக்கவைப்பின் சிக்கல்

இந்த பொதுவான சூழ்நிலையை கவனியுங்கள்:

            function outerFunction() {
 let largeData = new Array(1000000).fill('some data'); // Large array
 let innerFunction = function() {
 console.log('Inner function accessed.');
 };
 return innerFunction;
}

let myClosure = outerFunction();
// outerFunction has finished, but myClosure still exists

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `largeData` என்பது `outerFunction` க்குள் அறிவிக்கப்பட்ட ஒரு பெரிய வரிசையாகும். `outerFunction` அதன் செயல்பாட்டை முடித்திருந்தாலும், `myClosure` (`innerFunction` ஐக் குறிக்கிறது) இன்னும் `outerFunction` இன் லெக்சிகல் சூழலுக்கான குறிப்பை வைத்திருக்கிறது, இதில் `largeData` அடங்கும். இதன் விளைவாக, `largeData` நினைவகத்தில் உள்ளது, அது தீவிரமாகப் பயன்படுத்தப்படாவிட்டாலும் கூட. இது ஒரு சாத்தியமான நினைவக கசிவு.

இது ஏன் நடக்கிறது? இனி தேவையில்லாத நினைவகத்தை தானாகவே மீட்டெடுக்க JavaScript எஞ்சின் ஒரு குப்பை சேகரிப்பாளரைப் பயன்படுத்துகிறது. இருப்பினும், ஒரு பொருள் ரூட் (உலகளாவிய பொருள்) இலிருந்து இனி அடைய முடியாவிட்டால் மட்டுமே குப்பை சேகரிப்பவர் நினைவகத்தை மீட்டெடுக்கிறார். இந்த விஷயத்தில், `largeData` `myClosure` மாறி மூலம் அடைய முடியும், இது குப்பை சேகரிப்பைத் தடுக்கிறது.

க்ளோஷர்களில் நினைவக கசிவுகளைத் தணித்தல்

க்ளோஷர்களால் ஏற்படும் நினைவக கசிவுகளைத் தணிக்க பல உத்திகள் இங்கே:

1. குறிப்புகளை ரத்து செய்தல்: இனி க்ளோஷர் தேவையில்லை என்று உங்களுக்குத் தெரிந்தால், க்ளோஷர் மாறியை வெளிப்படையாக `null` ஆக அமைக்கலாம். இது குறிப்பு சங்கிலியை உடைத்து, குப்பை சேகரிப்பவர் நினைவகத்தை மீட்டெடுக்க அனுமதிக்கிறது.

               myClosure = null; // Break the reference
   
               
   
                 
                   Copy
                 
               
             

2. ஸ்கோப்பிங் கவனமாக: அதிக அளவு தரவைப் பிடிக்க தேவையில்லாமல் க்ளோஷர்களை உருவாக்குவதைத் தவிர்க்கவும். ஒரு க்ளோஷருக்கு தரவின் ஒரு சிறிய பகுதி மட்டுமே தேவைப்பட்டால், முழு ஸ்கோப்பையும் அணுகுவதற்கு க்ளோஷரை நம்புவதற்குப் பதிலாக அந்த பகுதியை ஒரு வாதமாக அனுப்ப முயற்சிக்கவும்.

               function outerFunction(dataNeeded) {
    let innerFunction = function() {
    console.log('Inner function accessed with:', dataNeeded);
    };
    return innerFunction;
   }
   
   let largeData = new Array(1000000).fill('some data');
   let myClosure = outerFunction(largeData.slice(0, 100)); // Pass only a portion
   
               
   
                 
                   Copy
                 
               
             

3. `let` மற்றும் `const` ஐப் பயன்படுத்துதல்: `var` க்கு பதிலாக `let` மற்றும் `const` ஐப் பயன்படுத்துவது மாறிகளின் ஸ்கோப்பைக் குறைக்க உதவும், ஒரு மாறி இனி தேவையில்லை என்பதை குப்பை சேகரிப்பாளருக்கு தீர்மானிப்பதை எளிதாக்குகிறது.
4. வீனமான வரைபடங்கள் மற்றும் பலவீனமான தொகுப்புகள்: இந்த தரவு கட்டமைப்புகள் குப்பை சேகரிக்கப்படுவதைத் தடுக்காமல் பொருட்களைக் குறிப்புகளை வைத்திருக்க உங்களை அனுமதிக்கின்றன. பொருள் குப்பை சேகரிக்கப்பட்டால், வீக் மேப் அல்லது வீக் செட்டில் உள்ள குறிப்பு தானாகவே அகற்றப்படும். இது நினைவக கசிவுகளுக்கு பங்களிக்காத வகையில் தரவை பொருட்களுடன் தொடர்புபடுத்த பயனுள்ளதாக இருக்கும்.
5. சரியான நிகழ்வு கேட்போர் மேலாண்மை: வலை மேம்பாட்டில், க்ளோஷர்கள் பெரும்பாலும் நிகழ்வு கேட்பவர்களுடன் பயன்படுத்தப்படுகின்றன. நினைவக கசிவுகளைத் தடுக்க, இனி தேவையில்லாதபோது நிகழ்வு கேட்பவர்களை அகற்றுவது மிகவும் முக்கியமானது. எடுத்துக்காட்டாக, டோம் இலிருந்து பின்னர் அகற்றப்படும் டோம் உறுப்புக்கு ஒரு நிகழ்வு கேட்பவரை இணைத்தால், நீங்கள் அதை வெளிப்படையாக அகற்றாவிட்டால், நிகழ்வு கேட்பவர் (மற்றும் அதனுடன் தொடர்புடைய க்ளோஷர்) இன்னும் நினைவகத்தில் இருக்கும். கேட்பவர்களை துண்டிக்க `removeEventListener` ஐப் பயன்படுத்தவும்.

               element.addEventListener('click', myClosure);
   // Later, when the element is no longer needed:
   element.removeEventListener('click', myClosure);
   myClosure = null;
   
               
   
                 
                   Copy
                 
               
             

நடைமுறை எடுத்துக்காட்டு: சர்வதேசமயமாக்கல் (i18n) நூலகங்கள்

லோக்கேல்-குறிப்பிட்ட தரவை சேமிக்க க்ளோஷர்களைப் பயன்படுத்தும் சர்வதேசமயமாக்கல் நூலகத்தைக் கவனியுங்கள். இந்த தரவை உள்ளடக்குவதற்கும் அணுகுவதற்கும் க்ளோஷர்கள் திறமையானவை என்றாலும், முறையற்ற மேலாண்மை நினைவக கசிவுகளுக்கு வழிவகுக்கும், குறிப்பாக ஒற்றை-பக்க பயன்பாடுகளில் (எஸ்பிஏக்கள்) லோக்கேல்கள் அடிக்கடி மாற்றப்படலாம். லோக்கேல் இனி தேவையில்லாதபோது, ​​மேலே குறிப்பிட்டுள்ள நுட்பங்களில் ஒன்றைப் பயன்படுத்தி தொடர்புடைய க்ளோஷர் (மற்றும் அதன் சேமிக்கப்பட்ட தரவு) முறையாக வெளியிடப்படுவதை உறுதிசெய்க.

ஸ்கோப் பாதுகாப்பு மற்றும் மேம்பட்ட வடிவங்கள்

நினைவக மேலாண்மைக்கு அப்பால், சக்திவாய்ந்த நிரலாக்க முறைகளை உருவாக்குவதற்கு க்ளோஷர்கள் அவசியம். அவை தரவு காப்புரிமை, தனிப்பட்ட மாறிகள் மற்றும் மட்டுத்தன்மை போன்ற நுட்பங்களை செயல்படுத்துகின்றன.

தனிப்பட்ட மாறிகள் மற்றும் தரவு காப்புரிமை

ஜாவா அல்லது சி ++ போன்ற மொழிகளைப் போலவே ஜாவாஸ்கிரிப்ட் தனிப்பட்ட மாறிகளுக்கு வெளிப்படையான ஆதரவைக் கொண்டிருக்கவில்லை. இருப்பினும், ஒரு செயல்பாட்டின் ஸ்கோப்பிற்குள் அவற்றைக் காப்ஸ்யூலிங் செய்வதன் மூலம் க்ளோஷர்கள் தனிப்பட்ட மாறிகளை உருவகப்படுத்த ஒரு வழியை வழங்குகின்றன. வெளிப்புற செயல்பாட்டிற்குள் அறிவிக்கப்பட்ட மாறிகள் உள் செயல்பாட்டிற்கு மட்டுமே அணுகக்கூடியவை, அவற்றை திறம்பட தனிப்பட்டதாக ஆக்குகின்றன.

            function createCounter() {
 let count = 0; // Private variable

 return {
 increment: function() {
 count++;
 return count;
 },
 decrement: function() {
 count--;
 return count;
 },
 getCount: function() {
 return count;
 }
 };
}

let counter = createCounter();
console.log(counter.increment()); // 1
console.log(counter.decrement()); // 0
console.log(counter.getCount()); // 0
//count; // Error: count is not defined

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `count` என்பது `createCounter` இன் ஸ்கோப்பிற்குள் மட்டுமே அணுகக்கூடிய ஒரு தனிப்பட்ட மாறி. திருப்பி அனுப்பப்பட்ட பொருள் முறைகளை வெளிப்படுத்துகிறது (`increment`, `decrement`, `getCount`) அவை `count` ஐ அணுகி மாற்ற முடியும், ஆனால் `count` நேரடியாக `createCounter` செயல்பாட்டிற்கு வெளியே இருந்து அணுக முடியாது. இது தரவைப் பாதுகாக்கிறது மற்றும் தற்செயலான மாற்றங்களைத் தடுக்கிறது.

தொகுதி முறை

தொகுதி முறை தனிப்பட்ட நிலை மற்றும் பொதுவான ஏபிஐ கொண்ட சுயாதீனமான தொகுதிகளை உருவாக்க க்ளோஷர்களைப் பயன்படுத்துகிறது. ஜாவாஸ்கிரிப்ட் குறியீட்டை ஒழுங்கமைப்பதற்கும் மட்டுத்தன்மையை மேம்படுத்துவதற்கும் இது ஒரு அடிப்படை முறை.

            let myModule = (function() {
 let privateVariable = 'Secret';

 function privateMethod() {
 console.log('Inside privateMethod:', privateVariable);
 }

 return {
 publicMethod: function() {
 console.log('Inside publicMethod.');
 privateMethod(); // Accessing private method
 }
 };
})();

myModule.publicMethod(); // Output: Inside publicMethod.
 // Inside privateMethod: Secret
//myModule.privateMethod(); // Error: myModule.privateMethod is not a function
//console.log(myModule.privateVariable); // undefined

            

              
                Copy
              
            
          

தொகுதி முறை ஒரு உடனடியாக அழைக்கப்படும் செயல்பாடு வெளிப்பாடு (ஐஐஎஃப்இ) ஒரு தனிப்பட்ட ஸ்கோப்பை உருவாக்க பயன்படுத்துகிறது. ஐஐஎஃப்இக்குள் அறிவிக்கப்பட்ட மாறிகள் மற்றும் செயல்பாடுகள் தொகுதிக்கு தனிப்பட்டவை. தொகுதி ஒரு பொதுவான ஏபிஐயை வெளிப்படுத்தும் ஒரு பொருளை வழங்குகிறது, இது தொகுதியின் செயல்பாட்டிற்கு கட்டுப்படுத்தப்பட்ட அணுகலை அனுமதிக்கிறது.

கறி செய்தல் மற்றும் பகுதி பயன்பாடு

கறி செய்தல் மற்றும் பகுதி பயன்பாடு, செயல்பாட்டு நிரலாக்க நுட்பங்கள் குறியீடு மறுபயனாக்கம் மற்றும் நெகிழ்வுத்தன்மையை மேம்படுத்துகின்றன.

கறி செய்தல்: கறி செய்தல் பல வாதங்களை எடுக்கும் ஒரு செயல்பாட்டை செயல்பாடுகளின் வரிசையாக மாற்றுகிறது, ஒவ்வொன்றும் ஒரு வாதத்தை எடுத்துக்கொள்கின்றன. அனைத்து வாதங்களும் வழங்கப்படும் வரை ஒவ்வொரு செயல்பாடும் அடுத்த வாதத்தை எதிர்பார்க்கும் மற்றொரு செயல்பாட்டை வழங்குகிறது.

            function multiply(a) {
 return function(b) {
 return function(c) {
 return a * b * c;
 };
 };
}

let multiplyBy5 = multiply(5);
let multiplyBy5And6 = multiplyBy5(6);
let result = multiplyBy5And6(7);
console.log(result); // Output: 210

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `multiply` என்பது கறி செய்யப்பட்ட செயல்பாடாகும். ஒவ்வொரு நெஸ்ட்டு செயல்பாடும் வெளிப்புற செயல்பாடுகளின் வாதங்களுக்கு மேல் மூடப்படுகிறது, அனைத்து வாதங்களும் கிடைக்கும்போது இறுதி கணக்கீடு செய்ய அனுமதிக்கிறது.

பகுதி பயன்பாடு: பகுதி பயன்பாடு ஒரு செயல்பாட்டின் சில வாதங்களை முன் நிரப்புவதை உள்ளடக்கியது, இது குறைக்கப்பட்ட எண்ணிக்கையிலான வாதங்களுடன் புதிய செயல்பாட்டை உருவாக்குகிறது.

            function greet(greeting, name) {
 return greeting + ', ' + name + '!';
}

function partial(func, arg1) {
 return function(arg2) {
 return func(arg1, arg2);
 };
}

let greetHello = partial(greet, 'Hello');
let message = greetHello('World');
console.log(message); // Output: Hello, World!

            

              
                Copy
              
            
          

இங்கே, `partial` `greet` செயல்பாட்டின் `greeting` வாதத்தை முன் நிரப்புவதன் மூலம் ஒரு புதிய செயல்பாட்டை `greetHello` உருவாக்குகிறது. `greeting` வாதத்தை "நினைவில் கொள்ள" க்ளோஷர் `greetHello` ஐ அனுமதிக்கிறது.

நிகழ்வு கையாளுதலில் க்ளோஷர்கள்

முன்னர் குறிப்பிட்டபடி, க்ளோஷர்கள் அடிக்கடி நிகழ்வு கையாளுதலில் பயன்படுத்தப்படுகின்றன. பல நிகழ்வு தீப்பிடிப்புகளிலும் நீடிக்கும் ஒரு நிகழ்வு கேட்பவருடன் தரவை தொடர்புபடுத்த அவை உங்களை அனுமதிக்கின்றன.

            function createButton(label, callback) {
 let button = document.createElement('button');
 button.textContent = label;
 button.addEventListener('click', function() {
 callback(label); // Closure over 'label'
 });
 document.body.appendChild(button);
}

createButton('Click Me', function(label) {
 console.log('Button clicked:', label);
});

            

              
                Copy
              
            
          

`addEventListener` க்கு அனுப்பப்பட்ட அநாமதேய செயல்பாடு `label` மாறியின் மேல் ஒரு க்ளோஷரை உருவாக்குகிறது. பொத்தான் கிளிக் செய்யப்படும்போது, ​​சரியான லேபிள் திரும்ப அழைப்பு செயல்பாட்டிற்கு அனுப்பப்படுவதை இது உறுதி செய்கிறது.

க்ளோஷர்களைப் பயன்படுத்துவதற்கான சிறந்த நடைமுறைகள்

• நினைவக பயன்பாட்டை மனதில் கொள்ளுங்கள்: க்ளோஷர்களின் நினைவக தாக்கங்களை எப்போதும் கருத்தில் கொள்ளுங்கள், குறிப்பாக பெரிய தரவுத்தொகுப்புகளுடன் பணிபுரியும் போது. நினைவக கசிவுகளைத் தடுக்க முன்னர் விவரிக்கப்பட்ட நுட்பங்களைப் பயன்படுத்தவும்.
• குறிக்கோளுடன் க்ளோஷர்களைப் பயன்படுத்தவும்: தேவையில்லாமல் க்ளோஷர்களைப் பயன்படுத்த வேண்டாம். ஒரு எளிய செயல்பாடு ஒரு க்ளோஷரை உருவாக்காமல் விரும்பிய முடிவை அடைய முடிந்தால், அது பெரும்பாலும் சிறந்த அணுகுமுறை.
• உங்கள் க்ளோஷர்களை ஆவணப்படுத்துங்கள்: உங்கள் க்ளோஷர்களின் நோக்கத்தை ஆவணப்படுத்த மறக்காதீர்கள், குறிப்பாக அவை சிக்கலானதாக இருந்தால். இது மற்ற டெவலப்பர்கள் (மற்றும் உங்கள் எதிர்கால சுய) குறியீட்டைப் புரிந்துகொள்ளவும் சாத்தியமான சிக்கல்களைத் தவிர்க்கவும் உதவும்.
• உங்கள் குறியீட்டை முழுமையாக சோதிக்கவும்: க்ளோஷர்களைப் பயன்படுத்தும் உங்கள் குறியீட்டை அது எதிர்பார்த்தபடி செயல்படுவதையும் நினைவகத்தைக் கசியவிடாது என்பதையும் உறுதிப்படுத்த முழுமையாக சோதிக்கவும். நினைவக பயன்பாட்டை பகுப்பாய்வு செய்ய உலாவி டெவலப்பர் கருவிகள் அல்லது நினைவக சுயவிவர கருவிகளைப் பயன்படுத்தவும்.
• ஸ்கோப் செயினைப் புரிந்து கொள்ளுங்கள்: க்ளோஷர்களுடன் திறம்பட பணியாற்றுவதற்கு ஸ்கோப் செயினைப் பற்றிய உறுதியான புரிதல் முக்கியமானது. மாறிகள் எவ்வாறு அணுகப்படுகின்றன மற்றும் க்ளோஷர்கள் அவற்றின் சுற்றுப்புற ஸ்கோப்புகளுக்கான குறிப்புகளை எவ்வாறு பராமரிக்கின்றன என்பதை காட்சிப்படுத்தவும்.

முடிவுரை

JavaScript க்ளோஷர்கள் ஒரு சக்திவாய்ந்த மற்றும் பல்துறை அம்சமாகும், இது தரவு காப்புரிமை, மட்டுத்தன்மை மற்றும் செயல்பாட்டு நிரலாக்க நுட்பங்கள் போன்ற மேம்பட்ட நிரலாக்க முறைகளை செயல்படுத்துகிறது. இருப்பினும், அவர்கள் நினைவகத்தை கவனமாக நிர்வகிக்கும் பொறுப்புடன் வருகிறார்கள். க்ளோஷர்களின் நுணுக்கங்கள், நினைவக மேலாண்மையில் அவற்றின் தாக்கம் மற்றும் ஸ்கோப் பாதுகாப்பில் அவற்றின் பங்கு ஆகியவற்றை புரிந்துகொள்வதன் மூலம், டெவலப்பர்கள் சாத்தியமான ஆபத்துகளைத் தவிர்த்து அவற்றின் முழு திறனையும் பயன்படுத்த முடியும். க்ளோஷர்களை மாஸ்டரிங் செய்வது திறமையான ஜாவாஸ்கிரிப்ட் டெவலப்பராக மாறுவதற்கும் உலகளாவிய பார்வையாளர்களுக்காக வலுவான, அளவிடக்கூடிய மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கும் ஒரு குறிப்பிடத்தக்க படியாகும்.